(function(window) {
	
	var Sugar = (function() {
	
		// Core 构造函数
		var Core = function( selector, context ) {
			// 返回Core.fn.init的一个实例，实际操作会在init里
			return new Core.fn.init( selector, context ); 
		},
		
		// 检测html字符串跟id字符串
		quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/;
		
		// Core.fn 为 Core 对象（函数也为对象）的子对象
		// Core.prototype 为 Core 构造函数的原型属性，指向Core的原型对象，实例通过原型链进行寻找属性或者方法
		Core.fn = Core.prototype = {
			// 用Core.prototype = {} 进行原型属性的重写，
			// 会导致其内部的constructor属性不在指向构造函数，此时会指向Object，
			// 所以这里要进行重写，将constructor属性重新指向Core构造函数
			constructor: Core,
			// 初始化Core对象，根据selector参数不同，init进行分流操作
			init: function( selector, context ) {
				
				// 处理如：$() $("") $(null) $(undefined)
				if ( !selector ) {
					return this; // 返回实例本身
				}
				
				// 处理DOM对象
				if ( selector.nodeType ) {
					this.context = this[0] = selector;
					this.length = 1;
					return this;	
				}
				
				// 处理body只存在一次
				if ( selector === 'body' && !context && document.body ) {
					this.context = document;
					this[0] = document.body;
					this.selector = selector;
					this.length = 1;
					return this;
					
				}
				
				
				// 处理字符串
				if ( typeof selector === 'string' ) {
					
					
					
				} else if ( Core.isFunction( selector ) ) { // 处理function
					return Core.ready( selector );
					
				}
				
				if ( selector.selector !== undefined ) {
					this.selector = selector.selector;
					this.context = selector.context;	
				}
				return Core.makeArray( selector, this );
			}
		
		};
		
		// 将init的原型属性指向Core.fn，即通过init创建的实例会继承所有Core.fn对象下的属性跟方法，包括init本身
		Core.fn.init.prototype = Core.fn;
		
		// Core的静态方法，类型检测，返回'[object object]'等值
		Core.class2type = function( obj ) {
			return obj == null ?
				String( obj ) :
				Object.prototype.toString.call( obj ).toLowerCase() || 'object';
		};
		// Core的一些静态方法，类型检测方法的封装，返回值：true | false
		// 布尔
		Core.isBoolean = function( obj ) {
			return '[object boolean]' === Core.class2type( obj );
		};
		// 数字
		Core.isNumber = function( obj ) {
			return '[object number]' === Core.class2type( obj );
		};
		// 字符串
		Core.isString = function( obj ) {
			return "[object string]" === Core.class2type( obj );									
		};
		// 函数
		Core.isFunction = function( obj ) {
			return "[object function]" === Core.class2type( obj );									
		};
		// 数组
		Core.isArray = Array.isArray || function( obj ) {
			return "[object array]" === Core.class2type( obj );									
		};
		// 日期
		Core.isDate = function( obj ) {
			return "[object date]" === Core.class2type( obj );									
		};
		// 正则
		Core.isRegExp = function( obj ) {
			return "[object regExp]" === Core.class2type( obj );									
		};
		// 对象
		Core.isObject = function( obj ) {
			return "[object object]" === Core.class2type( obj );									
		};
		// window
		Core.isWindow = function( obj ) {
			return obj && typeof obj === 'object' && 'setTimeout' in obj;	
		}

		// Core的扩展方法，并且跟Core的子对象fn共享相同功能
		// 该扩展方法提供：
		// 1、将对象的属性跟方法扩展到Core下，即作为Core的静态属性跟方法
		// 2、扩展到fn对象下，作为实例的属性跟方法
		// 3、将多个对象的属性跟方法扩展到第一个对象中，如：
		//     $.extend(//第一个对象{//各种已有方法}, //第二个对象{//第二个对象的方法}, //第三个对象{}, //第四个对象{}, ...);
		// 4、支持深复制，在第一个参数传入true，程序自动会把第二个参数作为目标对象，之后的参数作为待扩展的对象
		Core.extend = Core.fn.extend = function() {
			// name 为待扩展对象的key
			// src 为目标对象的value
			// copy 为待扩展对象的value
			var name, src, copy, options, clone, copyIsArray,
				target = arguments[ 0 ], // 目标对象
				length = arguments.length, // 实参个数
				deep = false, // 是否深度复制
				i = 1; // 循环初始值
			
			// 如果第一个参数为布尔类型的值，说明是执行深复制的开关
			if ( Core.isBoolean( target ) ) {
				deep = target; // 将这个开关赋值给deep
				target = arguments[1] || {}; // 如果第一个是开关，那么将第二个作为目标对象
				i = 2;
			}
			
			// 如果目标不是一个对象或者函数（函数也是对象），就将对象设置为空对象
			if ( !Core.isObject( target ) && !Core.isFunction( target ) ) {
				target = {};
			}
			
			// 如果实参只有一个，或者当有开关时有两个，那么就把目标对象设定为Core或者实例
			// 把对象里的方法扩展到Core或者实例中
			if ( length === i ) {	
				target = this; // 将目标设定为Core或者实例
				--i; // i减1，减少循环次数
			}
			
			for ( ; i <  length; i++ ) {
				// 只有当待扩展对象存在时，执行以下操作
				if ( ( options = arguments[i] ) != null ) {
					// 遍历待扩展对象
					for ( name in options ) {
						src = target[ name ]; // 目标对象value
						copy = options[ name ]; // 待扩展对象value
						if ( target === copy ) { // 防止重复复制
							continue;
						}
						// 进行深度复制检测，递归调用
						if ( deep && copy && ( Core.isObject( copy ) || ( copyIsArray = Core.isArray( copy ) ) ) ) {
							if ( copyIsArray ) {
								copyIsArray = false;
								clone = src && Core.isArray( src ) ? src : [];
							} else {
								clone = src && Core.isObject( src ) ? src : {};
							}
							target[ name ] = Core.extend( deep, clone, copy ); // 递归调用
						} else if ( copy !== undefined ) {
							target[ name ] = copy;
						}
					}
				}
			}
			return target;
		};
		
		// 对Core扩展常用方法
		Core.extend({
			// domReady
			ready: function() {
				
				
			},
			// 迭代器
			each: function( obj, callback, args ) {
				var name, // 对象值
					length = obj.length, // 对象个数
					isObj = ( length === undefined ) || Core.isFunction( obj ),
					i = 0;
			
				if ( args ) {
					if ( isObj ) { // 如果是对象，用for语句遍历
						for ( name in obj ) {
							// 将obj[ name ] 调用每个回调函数
							if ( callback.apply( obj[ name ], args ) === false ) {
								break;
							}
						}
					} else {
						for ( ; i < length; ) {
							if ( callback.apply( obj[ i++ ], args ) === false ) {
								break;
							}
						}
					}
				
				} else {
					if ( isObj ) { 
						for ( name in obj ) {
							if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
								break;
							}
						}
					} else {
						for ( ; i < length; ) {
							if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
								break;
							}
						}
					}
				}
				return obj;
			},
			
			
			// 将dom转化成Sugar对象
			makeArray: function( array, results ) {
				var ret = results || [];
				if ( array != null ) {
					var type = Core.class2type( array );
					
					if ( array.length == null || type === '[object string]' || type === '[object function]' || type === '[object regexp]' || Core.isWindow( array ) ) {
						Array.prototype.push.call( ret, array );
					} else {
						Core.merge( ret, array );
						
					}
					
				}
				return ret;
			},
			
			merge: function( first, second ) {
				var i = first.length,
					j = 0;
				
				if ( typeof second.length === 'number') {
					for ( var l = second.length; j < l; j++ ) {
						first[ i++ ] = second[ j ];	
					}	
				} else {
					while ( second[j] !== undefined ) {
						first[ i++ ] = second[ j++ ];
					}	
				}
				first.length = i;
				return first;
				
			}

		});
		
		// cookie
		
		
		// ajax
		
		
		// 暴露给外层对象唯一的接口
		// 所有的属性跟方法都绑定到Core对象或者实例上了
		return Core; 
	})();
	
	// 给window的$跟Sugar全局变量复制，用户可以通过两个全局变量进行操作
	window.$ = window.Sugar = Sugar;
})(window);